/******************************************************************************
    Copyright (C) 2014 by Ruwen Hahn <palana@stunned.de>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/

#include "window-remux.hpp"

#include "obs-app.hpp"

#include <QCloseEvent>
#include <QDirIterator>
#include <QFileDialog>
#include <QItemDelegate>
#include <QLineEdit>
#include <QMessageBox>
#include <QMimeData>
#include <QPainter>
#include <QPushButton>
#include <QStandardItemModel>
#include <QStyledItemDelegate>
#include <QToolButton>
#include <QTimer>

#include "qt-wrappers.hpp"

#include <memory>
#include <cmath>

using namespace std;

enum RemuxEntryColumn {
	State,
	InputPath,
	OutputPath,

	Count
};

enum RemuxEntryRole {
	EntryStateRole = Qt::UserRole,
	NewPathsToProcessRole
};

/**********************************************************
  Delegate - Presents cells in the grid.
**********************************************************/

class RemuxEntryPathItemDelegate : public QStyledItemDelegate {
public:

	RemuxEntryPathItemDelegate(bool isOutput, const QString &defaultPath)
		: QStyledItemDelegate(),
		  isOutput(isOutput),
		  defaultPath(defaultPath)
	{
	}

	virtual QWidget *createEditor(QWidget *parent,
			const QStyleOptionViewItem & /* option */,
			const QModelIndex &index) const override
	{
		RemuxEntryState state = index.model()
				->index(index.row(), RemuxEntryColumn::State)
				.data(RemuxEntryRole::EntryStateRole)
				.value<RemuxEntryState>();
		if (state == RemuxEntryState::Pending ||
				state == RemuxEntryState::InProgress) {
			// Never allow modification of rows that are
			// in progress.
			return Q_NULLPTR;
		} else if (isOutput && state != RemuxEntryState::Ready) {
			// Do not allow modification of output rows
			// that aren't associated with a valid input.
			return Q_NULLPTR;
		} else if (!isOutput && state == RemuxEntryState::Complete) {
			// Don't allow modification of rows that are
			// already complete.
			return Q_NULLPTR;
		} else {
			QSizePolicy buttonSizePolicy(
					QSizePolicy::Policy::Minimum,
					QSizePolicy::Policy::Expanding,
					QSizePolicy::ControlType::PushButton);

			QWidget *container = new QWidget(parent);

			auto browseCallback = [this, container]()
			{
				const_cast<RemuxEntryPathItemDelegate *>(this)
						->handleBrowse(container);
			};

			auto clearCallback = [this, container]()
			{
				const_cast<RemuxEntryPathItemDelegate *>(this)
						->handleClear(container);
			};

			QHBoxLayout *layout = new QHBoxLayout();
			layout->setMargin(0);
			layout->setSpacing(0);

			QLineEdit *text = new QLineEdit();
			text->setObjectName(QStringLiteral("text"));
			text->setSizePolicy(QSizePolicy(
					QSizePolicy::Policy::Expanding,
					QSizePolicy::Policy::Expanding,
					QSizePolicy::ControlType::LineEdit));
			layout->addWidget(text);

			QToolButton *browseButton = new QToolButton();
			browseButton->setText("...");
			browseButton->setSizePolicy(buttonSizePolicy);
			layout->addWidget(browseButton);

			container->connect(browseButton, &QToolButton::clicked,
					browseCallback);

			// The "clear" button is not shown in output cells
			// or the insertion point's input cell.
			if (!isOutput && state != RemuxEntryState::Empty) {
				QToolButton *clearButton = new QToolButton();
				clearButton->setText("X");
				clearButton->setSizePolicy(buttonSizePolicy);
				layout->addWidget(clearButton);

				container->connect(clearButton,
						&QToolButton::clicked,
						clearCallback);
			}

			container->setLayout(layout);
			container->setFocusProxy(text);

			return container;
		}
	}

	virtual void setEditorData(QWidget *editor, const QModelIndex &index)
			const override
	{
		QLineEdit *text = editor->findChild<QLineEdit *>();
		text->setText(index.data().toString());

		editor->setProperty(PATH_LIST_PROP, QVariant());
	}

	virtual void setModelData(QWidget *editor,
			QAbstractItemModel *model,
			const QModelIndex &index) const override
	{
		// We use the PATH_LIST_PROP property to pass a list of
		// path strings from the editor widget into the model's
		// NewPathsToProcessRole. This is only used when paths
		// are selected through the "browse" or "delete" buttons
		// in the editor. If the user enters new text in the
		// text box, we simply pass that text on to the model
		// as normal text data in the default role.
		QVariant pathListProp = editor->property(PATH_LIST_PROP);
		if (pathListProp.isValid()) {
			QStringList list = editor->property(PATH_LIST_PROP)
					.toStringList();
			if (isOutput) {
				if (list.size() > 0)
					model->setData(index, list);
			} else
				model->setData(index, list,
						RemuxEntryRole::NewPathsToProcessRole);
		} else {
			QLineEdit *lineEdit = editor->findChild<QLineEdit *>();
			model->setData(index, lineEdit->text());
		}
	}

	virtual void paint(QPainter *painter,
			const QStyleOptionViewItem &option,
			const QModelIndex &index) const override
	{
		RemuxEntryState state = index.model()
				->index(index.row(), RemuxEntryColumn::State)
				.data(RemuxEntryRole::EntryStateRole)
				.value<RemuxEntryState>();

		QStyleOptionViewItem localOption = option;
		initStyleOption(&localOption, index);

		if (isOutput) {
			if (state != Ready) {
				QColor background = localOption.palette
						.color(QPalette::ColorGroup::Disabled,
						QPalette::ColorRole::Background);

				localOption.backgroundBrush = QBrush(background);
			}
		}

		QApplication::style()->drawControl(QStyle::CE_ItemViewItem,
				&localOption, painter);
	}

private:
	bool isOutput;
	QString defaultPath;

	const char *PATH_LIST_PROP = "pathList";

	void handleBrowse(QWidget *container)
	{
		QString OutputPattern =
				"(*.mp4 *.flv *.mov *.mkv *.ts *.m3u8)";
		QString InputPattern =
				"(*.flv *.mov *.mkv *.ts *.m3u8)";

		QLineEdit *text = container->findChild<QLineEdit *>();

		QString currentPath = text->text();
		if (currentPath.isEmpty())
			currentPath = defaultPath;

		bool isSet = false;
		if (isOutput) {
			QString newPath = QFileDialog::getSaveFileName(
					container, QTStr("Remux.SelectTarget"),
					currentPath, OutputPattern);

			if (!newPath.isEmpty()) {
				container->setProperty(PATH_LIST_PROP,
						QStringList() << newPath);
				isSet = true;
			}
		} else {
			QStringList paths = QFileDialog::getOpenFileNames(
					container,
					QTStr("Remux.SelectRecording"),
					currentPath,
					QTStr("Remux.OBSRecording")
					+ QString(" ") + InputPattern);

			if (!paths.empty()) {
				container->setProperty(PATH_LIST_PROP, paths);
				isSet = true;
			}
		}

		if (isSet)
			emit commitData(container);
	}

	void handleClear(QWidget *container)
	{
		// An empty string list will indicate that the entry is being
		// blanked and should be deleted.
		container->setProperty(PATH_LIST_PROP, QStringList());

		emit commitData(container);
	}
};

/**********************************************************
  Model - Manages the queue's data
**********************************************************/

int RemuxQueueModel::rowCount(const QModelIndex &) const
{
	return queue.length() + (isProcessing ? 0 : 1);
}

int RemuxQueueModel::columnCount(const QModelIndex &) const
{
	return RemuxEntryColumn::Count;
}

QVariant RemuxQueueModel::data(const QModelIndex &index, int role) const
{
	QVariant result = QVariant();

	if (index.row() >= queue.length()) {
		return QVariant();
	} else if (role == Qt::DisplayRole) {
		switch (index.column()) {
		case RemuxEntryColumn::InputPath:
			result = queue[index.row()].sourcePath;
			break;
		case RemuxEntryColumn::OutputPath:
			result = queue[index.row()].targetPath;
			break;
		}
	} else if (role == Qt::DecorationRole &&
			index.column() == RemuxEntryColumn::State) {
		result = getIcon(queue[index.row()].state);
	} else if (role == RemuxEntryRole::EntryStateRole) {
		result = queue[index.row()].state;
	}

	return result;
}

QVariant RemuxQueueModel::headerData(int section, Qt::Orientation orientation,
		int role) const
{
	QVariant result = QVariant();

	if (role == Qt::DisplayRole &&
			orientation == Qt::Orientation::Horizontal) {
		switch (section) {
		case RemuxEntryColumn::State:
			result = QString();
			break;
		case RemuxEntryColumn::InputPath:
			result = QTStr("Remux.SourceFile");
			break;
		case RemuxEntryColumn::OutputPath:
			result = QTStr("Remux.TargetFile");
			break;
		}
	}

	return result;
}

Qt::ItemFlags RemuxQueueModel::flags(const QModelIndex &index) const
{
	Qt::ItemFlags flags = QAbstractTableModel::flags(index);

	if (index.column() == RemuxEntryColumn::InputPath) {
		flags |= Qt::ItemIsEditable;
	} else if (index.column() == RemuxEntryColumn::OutputPath &&
		index.row() != queue.length()) {
		flags |= Qt::ItemIsEditable;
	}

	return flags;
}

bool RemuxQueueModel::setData(const QModelIndex &index, const QVariant &value,
		int role)
{
	bool success = false;

	if (role == RemuxEntryRole::NewPathsToProcessRole) {
		QStringList pathList = value.toStringList();

		if (pathList.size() == 0) {
			if (index.row() < queue.size()) {
				beginRemoveRows(QModelIndex(), index.row(),
						index.row());
				queue.removeAt(index.row());
				endRemoveRows();
			}
		} else {
			if (pathList.size() > 1 && index.row() < queue.length()) {
				queue[index.row()].sourcePath = pathList[0];
				checkInputPath(index.row());

				pathList.removeAt(0);

				success = true;
			}

			if (pathList.size() > 0) {
				int row = index.row();
				int lastRow = row + pathList.size() - 1;
				beginInsertRows(QModelIndex(), row, lastRow);

				for (QString path : pathList) {
					RemuxQueueEntry entry;
					entry.sourcePath = path;

					queue.insert(row, entry);
					row++;
				}
				endInsertRows();

				for (row = index.row(); row <= lastRow; row++) {
					checkInputPath(row);
				}

				success = true;
			}
		}
	} else if (index.row() == queue.length()) {
		QString path = value.toString();

		if (!path.isEmpty()) {
			RemuxQueueEntry entry;
			entry.sourcePath = path;

			beginInsertRows(QModelIndex(), queue.length() + 1,
				queue.length() + 1);
			queue.append(entry);
			endInsertRows();

			checkInputPath(index.row());
			success = true;
		}
	} else {
		QString path = value.toString();

		if (path.isEmpty()) {
			if (index.column() == RemuxEntryColumn::InputPath) {
				beginRemoveRows(QModelIndex(), index.row(),
						index.row());
				queue.removeAt(index.row());
				endRemoveRows();
			}
		} else {
			switch (index.column()) {
			case RemuxEntryColumn::InputPath:
				queue[index.row()].sourcePath = value.toString();
				checkInputPath(index.row());
				success = true;
				break;
			case RemuxEntryColumn::OutputPath:
				queue[index.row()].targetPath = value.toString();
				emit dataChanged(index, index);
				success = true;
				break;
			}
		}
	}

	return success;
}

QVariant RemuxQueueModel::getIcon(RemuxEntryState state)
{
	QVariant icon;
	QStyle *style = QApplication::style();

	switch (state) {
	case RemuxEntryState::Complete:
		icon = style->standardIcon(
			QStyle::SP_DialogApplyButton);
		break;

	case RemuxEntryState::InProgress:
		icon = style->standardIcon(
			QStyle::SP_ArrowRight);
		break;

	case RemuxEntryState::Error:
		icon = style->standardIcon(
			QStyle::SP_DialogCancelButton);
		break;

	case RemuxEntryState::InvalidPath:
		icon = style->standardIcon(
			QStyle::SP_MessageBoxWarning);
		break;

	default:
		break;
	}

	return icon;
}

void RemuxQueueModel::checkInputPath(int row)
{
	RemuxQueueEntry &entry = queue[row];

	if (entry.sourcePath.isEmpty()) {
		entry.state = RemuxEntryState::Empty;
	} else {
		QFileInfo fileInfo(entry.sourcePath);
		if (fileInfo.exists())
			entry.state = RemuxEntryState::Ready;
		else
			entry.state = RemuxEntryState::InvalidPath;

		if (entry.state == RemuxEntryState::Ready)
			entry.targetPath = fileInfo.path() + QDir::separator()
				+ fileInfo.completeBaseName() + ".mp4";
	}

	if (entry.state == RemuxEntryState::Ready && isProcessing)
		entry.state = RemuxEntryState::Pending;

	emit dataChanged(index(row, 0), index(row, RemuxEntryColumn::Count));
}

QFileInfoList RemuxQueueModel::checkForOverwrites() const
{
	QFileInfoList list;

	for (const RemuxQueueEntry &entry : queue) {
		if (entry.state == RemuxEntryState::Ready) {
			QFileInfo fileInfo(entry.targetPath);
			if (fileInfo.exists()) {
				list.append(fileInfo);
			}
		}
	}

	return list;
}

bool RemuxQueueModel::checkForErrors() const
{
	bool hasErrors = false;

	for (const RemuxQueueEntry &entry : queue) {
		if (entry.state == RemuxEntryState::Error) {
			hasErrors = true;
			break;
		}
	}

	return hasErrors;
}

void RemuxQueueModel::clearAll()
{
	beginRemoveRows(QModelIndex(), 0, queue.size() - 1);
	queue.clear();
	endRemoveRows();
}

void RemuxQueueModel::clearFinished()
{
	int index = 0;

	for (index = 0; index < queue.size(); index++) {
		const RemuxQueueEntry &entry = queue[index];
		if (entry.state == RemuxEntryState::Complete) {
			beginRemoveRows(QModelIndex(), index, index);
			queue.removeAt(index);
			endRemoveRows();
			index--;
		}
	}
}

bool RemuxQueueModel::canClearFinished() const
{
	bool canClearFinished = false;
	for (const RemuxQueueEntry &entry : queue)
		if (entry.state == RemuxEntryState::Complete) {
			canClearFinished = true;
			break;
		}

	return canClearFinished;
}

void RemuxQueueModel::beginProcessing()
{
	for (RemuxQueueEntry &entry : queue)
		if (entry.state == RemuxEntryState::Ready)
			entry.state = RemuxEntryState::Pending;

	// Signal that the insertion point no longer exists.
	beginRemoveRows(QModelIndex(), queue.length(), queue.length());
	endRemoveRows();

	isProcessing = true;

	emit dataChanged(index(0, RemuxEntryColumn::State),
			index(queue.length(), RemuxEntryColumn::State));
}

void RemuxQueueModel::endProcessing()
{
	for (RemuxQueueEntry &entry : queue) {
		if (entry.state == RemuxEntryState::Pending) {
			entry.state = RemuxEntryState::Ready;
		}
	}

	// Signal that the insertion point exists again.

	if (!autoRemux) {
		beginInsertRows(QModelIndex(), queue.length(), queue.length());
		endInsertRows();
	}

	isProcessing = false;

	emit dataChanged(index(0, RemuxEntryColumn::State),
		index(queue.length(), RemuxEntryColumn::State));
}

bool RemuxQueueModel::beginNextEntry(QString &inputPath, QString &outputPath)
{
	bool anyStarted = false;

	for (int row = 0; row < queue.length(); row++) {
		RemuxQueueEntry &entry = queue[row];
		if (entry.state == RemuxEntryState::Pending) {
			entry.state = RemuxEntryState::InProgress;

			inputPath = entry.sourcePath;
			outputPath = entry.targetPath;

			QModelIndex index = this->index(row,
					RemuxEntryColumn::State);
			emit dataChanged(index, index);

			anyStarted = true;
			break;
		}
	}

	return anyStarted;
}

void RemuxQueueModel::finishEntry(bool success)
{
	for (int row = 0; row < queue.length(); row++) {
		RemuxQueueEntry &entry = queue[row];
		if (entry.state == RemuxEntryState::InProgress) {
			if (success)
				entry.state = RemuxEntryState::Complete;
			else
				entry.state = RemuxEntryState::Error;

			QModelIndex index = this->index(row,
					RemuxEntryColumn::State);
			emit dataChanged(index, index);

			break;
		}
	}
}

/**********************************************************
  The actual remux window implementation
**********************************************************/

OBSRemux::OBSRemux(const char *path, QWidget *parent, bool autoRemux_)
	: QDialog   (parent),
	  queueModel(new RemuxQueueModel),
	  worker    (new RemuxWorker()),
	  ui        (new Ui::OBSRemux),
	  recPath   (path),
	  autoRemux (autoRemux_)
{
	setAcceptDrops(true);

	setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);

	ui->setupUi(this);

	ui->progressBar->setVisible(false);
	ui->buttonBox->button(QDialogButtonBox::Ok)->
			setEnabled(false);
	ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->
			setEnabled(false);

	if (autoRemux) {
		resize(280, 40);
		ui->tableView->hide();
		ui->buttonBox->hide();
		ui->label->hide();
	}

	ui->progressBar->setMinimum(0);
	ui->progressBar->setMaximum(1000);
	ui->progressBar->setValue(0);

	ui->tableView->setModel(queueModel);
	ui->tableView->setItemDelegateForColumn(RemuxEntryColumn::InputPath,
			new RemuxEntryPathItemDelegate(false, recPath));
	ui->tableView->setItemDelegateForColumn(RemuxEntryColumn::OutputPath,
			new RemuxEntryPathItemDelegate(true, recPath));
	ui->tableView->horizontalHeader()->setSectionResizeMode(
			QHeaderView::ResizeMode::Stretch);
	ui->tableView->horizontalHeader()->setSectionResizeMode(
			RemuxEntryColumn::State,
			QHeaderView::ResizeMode::Fixed);
	ui->tableView->setEditTriggers(
			QAbstractItemView::EditTrigger::CurrentChanged);

	installEventFilter(CreateShortcutFilter());

	ui->buttonBox->button(QDialogButtonBox::Ok)->
			setText(QTStr("Remux.Remux"));
	ui->buttonBox->button(QDialogButtonBox::Reset)->
			setText(QTStr("Remux.ClearFinished"));
	ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->
			setText(QTStr("Remux.ClearAll"));
	ui->buttonBox->button(QDialogButtonBox::Reset)->
			setDisabled(true);

	connect(ui->buttonBox->button(QDialogButtonBox::Ok),
			SIGNAL(clicked()), this, SLOT(beginRemux()));
	connect(ui->buttonBox->button(QDialogButtonBox::Reset),
			SIGNAL(clicked()), this, SLOT(clearFinished()));
	connect(ui->buttonBox->button(QDialogButtonBox::RestoreDefaults),
			SIGNAL(clicked()), this, SLOT(clearAll()));
	connect(ui->buttonBox->button(QDialogButtonBox::Close),
			SIGNAL(clicked()), this, SLOT(close()));

	worker->moveToThread(&remuxer);
	remuxer.start();

	//gcc-4.8 can't use QPointer<RemuxWorker> below
	RemuxWorker *worker_ = worker;
	connect(worker_, &RemuxWorker::updateProgress,
			this, &OBSRemux::updateProgress);
	connect(&remuxer, &QThread::finished, worker_, &QObject::deleteLater);
	connect(worker_, &RemuxWorker::remuxFinished,
			this, &OBSRemux::remuxFinished);
	connect(this, &OBSRemux::remux, worker_, &RemuxWorker::remux);

	// Guessing the GCC bug mentioned above would also affect
	// QPointer<RemuxQueueModel>? Unsure.
	RemuxQueueModel *queueModel_ = queueModel;
	connect(queueModel_,
			SIGNAL(rowsInserted(const QModelIndex &, int, int)),
			this,
			SLOT(rowCountChanged(const QModelIndex &, int, int)));
	connect(queueModel_,
			SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
			this,
			SLOT(rowCountChanged(const QModelIndex &, int, int)));

	QModelIndex index = queueModel->createIndex(0, 1);
	QMetaObject::invokeMethod(ui->tableView,
			"setCurrentIndex", Qt::QueuedConnection,
			Q_ARG(const QModelIndex &, index));
}

bool OBSRemux::stopRemux()
{
	if (!worker->isWorking)
		return true;

	// By locking the worker thread's mutex, we ensure that its
	// update poll will be blocked as long as we're in here with
	// the popup open.
	QMutexLocker lock(&worker->updateMutex);

	bool exit = false;

	if (QMessageBox::critical(nullptr,
			QTStr("Remux.ExitUnfinishedTitle"),
			QTStr("Remux.ExitUnfinished"),
			QMessageBox::Yes | QMessageBox::No,
			QMessageBox::No) ==
			QMessageBox::Yes) {
		exit = true;
	}

	if (exit) {
		// Inform the worker it should no longer be
		// working. It will interrupt accordingly in
		// its next update callback.
		worker->isWorking = false;
	}

	return exit;
}

OBSRemux::~OBSRemux()
{
	stopRemux();
	remuxer.quit();
	remuxer.wait();
}

void OBSRemux::rowCountChanged(const QModelIndex &, int, int)
{
	// See if there are still any rows ready to remux. Change
	// the state of the "go" button accordingly.
	// There must be more than one row, since there will always be
	// at least one row for the empty insertion point.
	if (queueModel->rowCount() > 1) {
		ui->buttonBox->button(QDialogButtonBox::Ok)->
				setEnabled(true);
		ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->
				setEnabled(true);
		ui->buttonBox->button(QDialogButtonBox::Reset)->
				setEnabled(queueModel->canClearFinished());
	} else {
		ui->buttonBox->button(QDialogButtonBox::Ok)->
				setEnabled(false);
		ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->
				setEnabled(false);
		ui->buttonBox->button(QDialogButtonBox::Reset)->
				setEnabled(false);
	}
}

void OBSRemux::dropEvent(QDropEvent *ev)
{
	QStringList urlList;

	for (QUrl url : ev->mimeData()->urls()) {
		QFileInfo fileInfo(url.toLocalFile());

		if (fileInfo.isDir()) {
			QStringList directoryFilter;
			directoryFilter <<
				"*.flv" <<
				"*.mp4" <<
				"*.mov" <<
				"*.mkv" <<
				"*.ts" <<
				"*.m3u8";

			QDirIterator dirIter(fileInfo.absoluteFilePath(),
					directoryFilter, QDir::Files,
					QDirIterator::Subdirectories);

			while (dirIter.hasNext()) {
				urlList.append(dirIter.next());
			}
		} else {
			urlList.append(fileInfo.canonicalFilePath());
		}
	}

	if (urlList.empty()) {
		QMessageBox::information(nullptr,
				QTStr("Remux.NoFilesAddedTitle"),
				QTStr("Remux.NoFilesAdded"), QMessageBox::Ok);
	} else if (!autoRemux) {
		QModelIndex insertIndex = queueModel->index(
				queueModel->rowCount() - 1,
				RemuxEntryColumn::InputPath);
		queueModel->setData(insertIndex, urlList,
				RemuxEntryRole::NewPathsToProcessRole);
	}
}

void OBSRemux::dragEnterEvent(QDragEnterEvent *ev)
{
	if (ev->mimeData()->hasUrls() && !worker->isWorking)
		ev->accept();
}

void OBSRemux::beginRemux()
{
	if (worker->isWorking) {
		stopRemux();
		return;
	}

	bool proceedWithRemux = true;
	QFileInfoList overwriteFiles = queueModel->checkForOverwrites();

	if (!overwriteFiles.empty()) {
		QString message = QTStr("Remux.FileExists");
		message += "\n\n";

		for (QFileInfo fileInfo : overwriteFiles)
			message += fileInfo.canonicalFilePath() + "\n";

		if (OBSMessageBox::question(this,
			QTStr("Remux.FileExistsTitle"), message)
			!= QMessageBox::Yes)
			proceedWithRemux = false;
	}

	if (!proceedWithRemux)
		return;

	// Set all jobs to "pending" first.
	queueModel->beginProcessing();

	ui->progressBar->setVisible(true);
	ui->buttonBox->button(QDialogButtonBox::Ok)->
			setText(QTStr("Remux.Stop"));
	setAcceptDrops(false);

	remuxNextEntry();
}

void OBSRemux::AutoRemux(QString inFile, QString outFile)
{
	if (inFile != "" && outFile != "" && autoRemux) {
		emit remux(inFile, outFile);
		autoRemuxFile = inFile;
	}
}

void OBSRemux::remuxNextEntry()
{
	worker->lastProgress = 0.f;

	QString inputPath, outputPath;
	if (queueModel->beginNextEntry(inputPath, outputPath)) {
		emit remux(inputPath, outputPath);
	} else {
		queueModel->autoRemux = autoRemux;
		queueModel->endProcessing();

		if (!autoRemux) {
			OBSMessageBox::information(this,
					QTStr("Remux.FinishedTitle"),
					queueModel->checkForErrors()
					? QTStr("Remux.FinishedError")
					: QTStr("Remux.Finished"));
		}

		ui->progressBar->setVisible(autoRemux);
		ui->buttonBox->button(QDialogButtonBox::Ok)->
				setText(QTStr("Remux.Remux"));
		ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->
				setEnabled(true);
		ui->buttonBox->button(QDialogButtonBox::Reset)->
				setEnabled(queueModel->canClearFinished());
		setAcceptDrops(true);
	}
}

void OBSRemux::closeEvent(QCloseEvent *event)
{
	if (!stopRemux())
		event->ignore();
	else
		QDialog::closeEvent(event);
}

void OBSRemux::reject()
{
	if (!stopRemux())
		return;

	QDialog::reject();
}

void OBSRemux::updateProgress(float percent)
{
	ui->progressBar->setValue(percent * 10);
}

void OBSRemux::remuxFinished(bool success)
{
	ui->buttonBox->button(QDialogButtonBox::Ok)->
			setEnabled(true);

	queueModel->finishEntry(success);

	if (autoRemux && autoRemuxFile != "") {
		QTimer::singleShot(3000, this, SLOT(close()));
	}

	remuxNextEntry();
}

void OBSRemux::clearFinished()
{
	queueModel->clearFinished();
}

void OBSRemux::clearAll()
{
	queueModel->clearAll();
}

/**********************************************************
  Worker thread - Executes the libobs remux operation as a
                  background process.
**********************************************************/

void RemuxWorker::UpdateProgress(float percent)
{
	if (abs(lastProgress - percent) < 0.1f)
		return;

	emit updateProgress(percent);
	lastProgress = percent;
}

void RemuxWorker::remux(const QString &source, const QString &target)
{
	isWorking = true;

	auto callback = [](void *data, float percent)
	{
		RemuxWorker *rw = static_cast<RemuxWorker*>(data);

		QMutexLocker lock(&rw->updateMutex);

		rw->UpdateProgress(percent);

		return rw->isWorking;
	};

	bool stopped = false;
	bool success = false;

	media_remux_job_t mr_job = nullptr;
	if (media_remux_job_create(&mr_job,
			QT_TO_UTF8(source),
			QT_TO_UTF8(target))) {

		success = media_remux_job_process(mr_job, callback,
			this);

		media_remux_job_destroy(mr_job);

		stopped = !isWorking;
	}

	isWorking = false;

	emit remuxFinished(!stopped && success);
}
